nanopyx.liquid._le_interpolation_nearest_neighbor_

  1import numpy as np
  2
  3from .__njit__ import njit, prange
  4
  5
  6def _interpolate(image, row, col, rows, cols):
  7    r = int(row)
  8    c = int(col)
  9    if r < 0 or r >= rows or c < 0 or c >= cols:
 10        return 0
 11    else:
 12        return image[r, c]
 13
 14
 15@njit(cache=True)
 16def _njit_interpolate(image, row, col, rows, cols):
 17    r = int(row)
 18    c = int(col)
 19    if r < 0 or r >= rows or c < 0 or c >= cols:
 20        return 0
 21    else:
 22        return image[r, c]
 23
 24
 25def shift_magnify(
 26    image: np.ndarray,
 27    shift_row: np.ndarray,
 28    shift_col: np.ndarray,
 29    magnification_row: float,
 30    magnification_col: float,
 31) -> np.ndarray:
 32    """
 33    Shift and magnify using nearest neighbor interpolation.
 34    :param image: 3D numpy array to interpolate with size (nFrames, nRow, nCol)
 35    :param shift_row: 1D array with size (nFrames) with values to shift the rows
 36    :param shift_col: 1D array with size (nFrames) with values to shift the cols
 37    :param magnification_row: float magnification factor for the rows
 38    :param magnification_col: float magnification factor for the cols
 39    :return: 3D float32 numpy array with the result
 40    """
 41
 42    nFrames = image.shape[0]
 43    rows = image.shape[1]
 44    cols = image.shape[2]
 45    rowsM = int(rows * magnification_row)
 46    colsM = int(cols * magnification_col)
 47
 48    image_out = np.zeros((nFrames, rowsM, colsM), dtype=np.float32)
 49    for f in range(nFrames):
 50        for j in range(colsM):
 51            col = j / magnification_col - shift_col[f]
 52            for i in range(rowsM):
 53                row = i / magnification_row - shift_row[f]
 54                image_out[f, i, j] = _interpolate(image[f, :, :], row, col, rows, cols)
 55
 56    return image_out
 57
 58
 59@njit(cache=True, parallel=True)
 60def njit_shift_magnify(
 61    image: np.ndarray,
 62    shift_row: np.ndarray,
 63    shift_col: np.ndarray,
 64    magnification_row: float,
 65    magnification_col: float,
 66) -> np.ndarray:
 67    """
 68    Shift and magnify using nearest neighbor interpolation.
 69    :param image: 3D numpy array to interpolate with size (nFrames, nRow, nCol)
 70    :param shift_row: 1D array with size (nFrames) with values to shift the rows
 71    :param shift_col: 1D array with size (nFrames) with values to shift the cols
 72    :param magnification_row: float magnification factor for the rows
 73    :param magnification_col: float magnification factor for the cols
 74    :return: 3D float32 numpy array with the result
 75    """
 76
 77    nFrames = image.shape[0]
 78    rows = image.shape[1]
 79    cols = image.shape[2]
 80    rowsM = int(rows * magnification_row)
 81    colsM = int(cols * magnification_col)
 82
 83    image_out = np.zeros((nFrames, rowsM, colsM), dtype=np.float32)
 84    for f in range(nFrames):
 85        for j in prange(colsM):
 86            col = j / magnification_col - shift_col[f]
 87            for i in range(rowsM):
 88                row = i / magnification_row - shift_row[f]
 89                image_out[f, i, j] = _njit_interpolate(
 90                    image[f, :, :], row, col, rows, cols
 91                )
 92
 93    return image_out
 94
 95
 96def shift_scale_rotate(
 97    image: np.ndarray,
 98    shift_row: np.ndarray,
 99    shift_col: np.ndarray,
100    scale_row: float,
101    scale_col: float,
102    angle: float,
103) -> np.ndarray:
104    """
105    Shift, magnify and rotate using nearest neighbor interpolation.
106    The order of operations is SCALE AND ROTATE AROUND CENTER THEN SHIFT
107    :param image: 3D numpy array to interpolate with size (nFrames, nRow, nCol)
108    :param shift_row: 1D array with size (nFrames) with values to shift the rows
109    :param shift_col: 1D array with size (nFrames) with values to shift the cols
110    :param scale_row: float scale factor for the rows
111    :param scale_col: float scale factor for the cols
112    :param angle: float angle of rotation in radians. positive is counter clockwise
113    :return: 3D float32 numpy array with the result
114    """
115
116    nFrames = image.shape[0]
117    rows = image.shape[1]
118    cols = image.shape[2]
119
120    center_row = rows / 2
121    center_col = cols / 2
122    # center_rowM = (rows * scale_row) / 2
123    # center_colM = (cols * scale_col) / 2
124
125    # Composing an affine transform
126    # Its scale => rotate => shift, but we iterate the final image so shift is the first operation on the vector
127    # SCALE     ROTATE         SHIFT
128    # sx  0 0   +cos -sin 0    0 0 tx   j     col
129    #  0 sy 0 . +sin +cos 0  . 0 0 ty . i  =  row
130    #  0  0 1     0    0  1    0 0  1   1      1
131
132    # After calculations we have
133    # SHIFT . SCALE . ROTATE = a  b  tcol
134    #                          c  d  trow
135    #                          0  0   1
136    # We multiply the matrix by every vector (i,j,1)
137    
138    a = np.cos(angle) / scale_col
139    b = -np.sin(angle)/ scale_col
140    c = np.sin(angle) / scale_row
141    d = np.cos(angle) / scale_row
142    
143    # Note#1:tcol and trow are simply shift_col and shift_row rotated and thus are functions of a,b,c,d
144    #   In the below code we simplify it by separating it by their common factors a,b,c,d
145
146    # Note#2: In reality we have to translate by the center before and after to have centered coordinates
147    # In order to keep the same image size during scaling the translation for centered coordinates is given by 
148    # (center_magnified - center_og) - center_magnified == center_og
149    # This can be seen by noting that when (i,j)=(0,0) we are actually at (center_magnified - center_og) coordinates on the scaled image
150
151    image_out = np.zeros((nFrames, rows, cols), dtype=np.float32)
152    for f in range(nFrames):
153        for j in range(cols):
154            for i in range(rows):
155                col = (
156                    (a * (j - center_col-shift_col[f]) + b * (i - center_row-shift_row[f]))
157                    + center_col
158                )
159                row = (
160                    (c * (j - center_col-shift_col[f]) + d * (i - center_row-shift_row[f]))
161                    + center_row
162                )
163                image_out[f, i, j] = _interpolate(image[f, :, :], row, col, rows, cols)
164
165    return image_out
166
167
168@njit(cache=True, parallel=True)
169def njit_shift_scale_rotate(
170    image: np.ndarray,
171    shift_row: np.ndarray,
172    shift_col: np.ndarray,
173    scale_row: float,
174    scale_col: float,
175    angle: float,
176) -> np.ndarray:
177    """
178    Shift, magnify and rotate using nearest neighbor interpolation.
179    The order of operations is SCALE AND ROTATE AROUND CENTER THEN SHIFT
180    :param image: 3D numpy array to interpolate with size (nFrames, nRow, nCol)
181    :param shift_row: 1D array with size (nFrames) with values to shift the rows
182    :param shift_col: 1D array with size (nFrames) with values to shift the cols
183    :param scale_row: float scale factor for the rows
184    :param scale_col: float scale factor for the cols
185    :param angle: float angle of rotation in radians. positive is counter clockwise
186    :return: 3D float32 numpy array with the result
187    """
188
189    nFrames = image.shape[0]
190    rows = image.shape[1]
191    cols = image.shape[2]
192
193    center_row = rows / 2
194    center_col = cols / 2
195
196    # center_rowM = (rows * scale_row) / 2
197    # center_colM = (cols * scale_col) / 2
198
199    a = np.cos(angle) / scale_col
200    b = -np.sin(angle) / scale_col
201    c = np.sin(angle) / scale_row
202    d = np.cos(angle) / scale_row
203
204    image_out = np.zeros((nFrames, rows, cols), dtype=np.float32)
205    for f in range(nFrames):
206        for j in prange(cols):
207            for i in range(rows):
208                col = (
209                    (a * (j - center_col-shift_col[f]) + b * (i - center_row-shift_row[f]))
210                    + center_col
211                )
212                row = (
213                    (c * (j - center_col-shift_col[f]) + d * (i - center_row-shift_row[f]))
214                    + center_row
215                )
216                image_out[f, i, j] = _njit_interpolate(image[f, :, :], row, col, rows, cols)
217
218    return image_out